Course: Android App Development
Topic: Understanding Android Versions, SDKs, and API Levels
Course Link: Android App Development Course
Demo Registration: Register for a Course Demo
Website: JustAcademy
Android application development requires an understanding of Android operating system versions, Software Development Kits (SDKs), and API levels. These concepts help developers select development tools, access platform features, maintain compatibility with different devices, and prepare applications for release.
Android runs on a wide range of smartphones, tablets, televisions, watches, and other devices. These devices may use different Android versions and support different platform APIs. Therefore, an application must be developed and tested with compatibility in mind.
For example, an application may use a feature introduced in Android 14 while also supporting devices running Android 10. The developer must ensure that the feature is used safely and that the application behaves correctly on older devices.
An Android version identifies a particular release of the Android operating system. Each major version may introduce new features, interface improvements, security updates, performance enhancements, and changes to developer APIs.
Android versions are identified by version numbers, such as Android 12, Android 13, Android 14, Android 15, and Android 16. Historically, Android releases also used dessert-themed codenames, including Oreo, Pie, and Nougat.
| Android Version | API Level | Important Learning Point |
|---|---|---|
| Android 8.0 Oreo | 26 | Introduced background execution limits and notification channels. |
| Android 9 Pie | 28 | Introduced platform improvements involving adaptive battery and display cutouts. |
| Android 10 | 29 | Introduced scoped storage changes and broader privacy improvements. |
| Android 11 | 30 | Expanded one-time permissions and introduced additional privacy controls. |
| Android 12 | 31 | Introduced Material You design and additional privacy features. |
| Android 12L | 32 | Focused on improvements for large screens and foldable devices. |
| Android 13 | 33 | Introduced notification permission requirements for many newly installed applications. |
| Android 14 | 34 | Added further privacy, security, accessibility, and platform behavior changes. |
| Android 15 | 35 | Introduced additional privacy, security, and user experience improvements. |
| Android 16 | 36 | Introduced further platform updates and compatibility considerations. |
Note: This table is a learning reference, not an exhaustive release history. Android releases and their API levels are documented in the official Android API level documentation.
SDK stands for Software Development Kit. It is a collection of tools, libraries, APIs, and utilities that developers use to build applications for a particular platform.
The Android SDK provides the resources required to develop, compile, test, debug, and package Android applications.
The Android SDK allows developers to access operating system functionality without implementing everything from scratch. It provides standardized interfaces for activities, services, permissions, notifications, storage, networking, and other platform capabilities.
For example, a developer creating a camera application can use Android camera APIs rather than writing a complete hardware driver. The application can focus on its own features while relying on platform-supported functionality.
An API level is an integer that identifies a revision of the Android framework API. It indicates which platform programming interfaces and system behaviors are available to applications.
Each Android platform release is associated with an API level. Developers use API levels to determine whether a particular API is available and to configure application compatibility.
For example:
| Concept | Meaning | Example |
|---|---|---|
| Android Version | The release of the Android operating system. | Android 14 |
| Android SDK | The collection of development tools, platform libraries, and utilities. | Android SDK installed through Android Studio |
| API Level | The integer identifying a revision of the Android framework API. | API level 34 for Android 14 |
| compileSdk | The API level against which the application is compiled. | 36 |
| minSdk | The lowest Android API level supported by the application. | 26 |
| targetSdk | The API level whose expected platform behavior the application targets. | 36 |
These terms are related but not interchangeable. The Android version identifies the operating system release, the SDK supplies development resources, and the API level identifies the platform API revision.
Android projects commonly configure three important SDK values: compileSdk, minSdk, and targetSdk. Understanding their different purposes helps developers avoid compatibility problems.
compileSdk specifies the Android API level used when compiling the application. It determines which platform APIs the compiler can recognize.
A newer compile SDK can provide access to newer API definitions. However, compiling against a newer SDK does not automatically mean the application supports every device or targets the latest runtime behavior.
minSdk specifies the minimum API level on which the application is intended to run. A device below this level generally cannot install the application through normal Android installation checks.
Choosing a lower minimum SDK can allow more older devices to install the application, but developers must ensure that the code works correctly on those devices.
targetSdk indicates the API level whose platform behavior the application is designed to support. Android may apply compatibility behavior based on this value, and Google Play imposes target API requirements for app submissions.
Targeting a newer API level may require developers to update permission handling, background work, notifications, or other platform-specific behavior.
| Setting | Main Purpose | Key Question |
|---|---|---|
| compileSdk | Controls the platform API definitions available during compilation. | Which Android APIs can I compile against? |
| minSdk | Defines the minimum supported Android API level. | What is the oldest Android version my app supports? |
| targetSdk | Declares the Android API level whose behavior the app targets. | Which Android platform behavior has my app been prepared for? |
In modern Android projects, SDK values are commonly configured in the module-level Gradle build file. The following example uses Kotlin DSL.
android {
namespace = "com.example.myapp"
compileSdk = 36
defaultConfig {
applicationId = "com.example.myapp"
minSdk = 26
targetSdk = 36
versionCode = 1
versionName = "1.0"
}
}Explanation:
namespace identifies the namespace used for generated application classes.compileSdk = 36 compiles the application against API level 36.minSdk = 26 sets API level 26 as the minimum supported level in this example.targetSdk = 36 declares API level 36 as the target.versionCode is an integer used for application version ordering.versionName is the user-visible version label.These values are examples, not universal recommendations. Choose compatible SDK values according to your project requirements, installed development tools, supported devices, and current distribution policies.
Android Studio provides a convenient way to inspect and update SDK settings.
build.gradle.kts or build.gradle file.android configuration block.compileSdk, minSdk, and targetSdk values.Before testing an application, developers should identify the Android version running on the test device.
The exact menu names may vary between manufacturers.
When Android Debug Bridge is available and the device is connected with debugging enabled, run:
adb shell getprop ro.build.version.release
adb shell getprop ro.build.version.sdkThe first command displays the Android release version, while the second returns the device's API level.
Android applications can inspect the API level at runtime to determine whether a platform-specific feature is available.
import android.os.Build
import android.util.Log
fun checkAndroidVersion() {
val apiLevel = Build.VERSION.SDK_INT
if (apiLevel >= Build.VERSION_CODES.TIRAMISU) {
Log.d("AndroidVersion", "Android 13 or newer")
} else {
Log.d("AndroidVersion", "Older than Android 13")
}
}Build.VERSION.SDK_INT returns the device's platform API level.Build.VERSION_CODES.TIRAMISU represents API level 33, corresponding to Android 13.Use runtime checks only where needed. Prefer compatibility libraries and version-independent APIs when they provide the required behavior.
A common compatibility problem occurs when an application calls an API that does not exist on the device's Android version. This can cause runtime errors if the code is not guarded properly.
For example, suppose a feature requires API level 33 or later. The application can check the current API level before calling the feature-specific code.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
// Call an API that requires Android 13 or later.
} else {
// Use a compatible alternative or disable the feature.
}When implementing this pattern, make sure the newer API is actually available at the checked API level and provide an appropriate fallback for older devices.
The SDK Manager is a tool in Android Studio used to install, update, and manage Android development components.
Before upgrading a production project, review release notes, check plugin compatibility, and test the build instead of changing every dependency without verification.
Backward compatibility means allowing an application to continue working on older supported platform versions while using newer platform capabilities where available.
Android developers often maintain compatibility by setting a suitable minimum SDK, using compatibility libraries, checking API availability, and testing different system versions.
Suppose an application supports API level 26 and uses a feature introduced at API level 33. The application can still support older devices if the feature is guarded and an appropriate alternative is provided where necessary.
Google Play sets target API level requirements for applications submitted to its store. These requirements change over time and can differ by device category and application type.
As of October 28, 2026, Google Play's published requirements state that new apps and app updates generally must target Android 16 (API level 36) or higher from August 31, 2026, subject to the published exceptions and extension provisions. Developers should verify the latest requirements before submitting an app.
Targeting a recent API level is not the same as setting the minimum supported Android version. An application can target a recent API level while supporting older devices through a lower minimum SDK, provided its implementation remains compatible.
Official reference: Google Play target API level requirements.
| Problem | Possible Cause | Solution |
|---|---|---|
| Unresolved Android API reference | The selected compile SDK does not include the API. | Check the API's introduction level and update the compile SDK when appropriate. |
| Application cannot install on an older device | The device API level is lower than the app's minimum SDK. | Review the minimum SDK and determine whether older-device support is feasible. |
| Runtime crash on an older device | The code calls an unavailable API. | Add appropriate API checks or use a compatible implementation. |
| Unexpected behavior on a newer Android version | Platform behavior changes or compatibility requirements. | Review Android behavior-change documentation and test the application. |
| Gradle sync failure | Incompatible Gradle, Android Gradle Plugin, JDK, or SDK configuration. | Check the compatibility requirements for the installed tool versions. |
| Google Play rejects a release | The target API level or another store requirement is not satisfied. | Review the current Play Console policy and update the project as required. |
Create a simple Android application and practice configuring its SDK values.
Answer: An Android version identifies a release of the Android operating system, such as Android 13, Android 14, or Android 15.
Answer: The Android SDK is a collection of platform libraries, development tools, build utilities, and testing resources used to create Android applications.
Answer: An API level is an integer that identifies a revision of the Android framework API.
Answer: compileSdk controls the platform APIs available during compilation, while minSdk defines the minimum Android API level supported by the application.
Answer: targetSdk declares the API level whose platform behavior the application is designed to support. It also affects compatibility behavior and is relevant to Google Play submission requirements.
Answer: Yes, if its minimum SDK permits Android 10 and the code is compatible with that version. APIs introduced after Android 10 must be handled appropriately.
Answer: Use Build.VERSION.SDK_INT to retrieve the integer API level at runtime.
Answer: Calling a framework API that does not exist on the device can cause a runtime error. Developers should check API availability or use a compatible alternative.
Answer: SDK Manager is an Android Studio tool used to install and manage Android SDK platforms, build tools, platform tools, and other development components.
Answer: Different versions can have different APIs, permissions, and system behavior. Testing helps identify compatibility issues and ensures the application works on supported devices.
Understanding Android versions, SDKs, and API levels is essential for building reliable Android applications. Android versions identify operating system releases, the SDK supplies development tools and platform libraries, and API levels identify the framework APIs available on each platform release.
By configuring compileSdk, minSdk, and targetSdk correctly, checking API availability, and testing across supported devices, developers can create applications that take advantage of modern Android features while maintaining compatibility with their intended users.
Continue learning about Android development through these resources:
